Java 21 – Was ist neu im neuesten LTS?

Oft hört man, dass Java 21 einfach „das neueste LTS“ ist – doch die Realität ist etwas komplexer. Java 21 ist eine Sammlung von Spezifikationen, die das Verhalten der Sprache, virtuellen Maschine, Bibliotheken usw. beschreiben. Die Referenzimplementierung (OpenJDK) wird im OpenJDK-Repository entwickelt, und nach der Veröffentlichung wird der JDK21U-Branch erstellt, um Sicherheitsupdates und Fehlerbehebungen zu erhalten.

Das bedeutet jedoch nicht, dass JDK21U unbegrenzt unterstützt wird. Hier kommen JDK-Distributoren ins Spiel, wie Eclipse Temurin, Oracle, Red Hat, Azul oder Amazon, die eigene JDK-Binärdateien erstellen und häufig kommerziellen Support anbieten. In der Praxis ist „Java 21 als LTS“ eher eine Anbieteraussage als Teil der Sprachspezifikation.

In diesem Artikel konzentriere ich mich auf die Migration von Java 17 auf Java 21 und ausgewählte Funktionen. Wenn Sie sich fragen, ob sich ein Umstieg auf die neue Version lohnt oder ein neues Projekt damit starten wollen – dieser Beitrag ist für Sie!

Virtuelle Threads

Virtuelle Threads sind die größte Veränderung in der Nebenläufigkeit seit der Einführung von ForkJoinPool. Im traditionellen Java-Modell wurden Threads Betriebssystem-Threads zugeordnet. Dieser Ansatz funktioniert, ist aber teuer – OS-Threads verbrauchen viel Speicher und sind begrenzt.

Jeder Thread kann lange blockiert sein, z. B. beim Warten auf eine HTTP-Antwort, obwohl die tatsächliche Verarbeitung sehr kurz ist. Bisher wurde dies meist durch asynchronen Code gelöst, der oft schwer zu warten ist.

Virtuelle Threads bieten einen neuen Ansatz – man kann synchronen Code mit asynchronem Verhalten schreiben, ohne die Belastung durch OS-Threads.

Beispielergebnis (System-Threads):

Anzahl der Threads = 1000, Zeit (ms) = 1100  
Anzahl der Threads = 10000, Zeit (ms) = 1600  
Anzahl der Threads = 100000, Zeit (ms) = 5300  
Kritischer Fehler: Stack-Speichergrenze überschritten
          

Bei einer großen Anzahl an Threads stürzt das Programm ab oder wirft einen OutOfMemoryError.

Version mit virtuellen Threads (VirtualThreads.java):

Anzahl der Threads = 1000, Zeit (ms) = 1020  
Anzahl der Threads = 10000, Zeit (ms) = 1056  
Anzahl der Threads = 100000, Zeit (ms) = 1106  
Anzahl der Threads = 1000000, Zeit (ms) = 1806  
Anzahl der Threads = 10000000, Zeit (ms) = 22010
          

Im Gegensatz zum vorherigen Ansatz stürzt die Anwendung nicht ab und kann problemlos Millionen von Threads gleichzeitig verarbeiten.

Sequenzierte Collections

Java bietet seit langem verschiedene Collection-Implementierungen – List, Set, Map – aber nicht alle garantieren eine konsistente Verarbeitung in definierter Reihenfolge.

Java 21 führt ein neues Interface ein: SequencedCollection, das die Verarbeitung von Collections mit logischer Reihenfolge standardisiert.

Was ist eine SequencedCollection?

public interface SequencedCollection<E> extends Collection<E> {
    E getFirst();
    E getLast();
    SequencedCollection<E> reversed();
}
          

Es gibt auch:

• SequencedSet<E> – z. B. LinkedHashSet
• SequencedMap<K,V> – z. B. LinkedHashMap

Damit kann man z. B. Maps in umgekehrter Reihenfolge durchlaufen – ohne die Einträge manuell zu invertieren. Ein Beispiel dafür, wie sich das Java-API weiterentwickelt – statt bestehende Klassen zu verändern, werden schlanke, semantische Interfaces ergänzt.

Pattern Matching für switch

Viele Jahre war switch in Java eine einfache Kontrollstruktur für primitive Werte (int, enum, String). Mit Java 21 wird sie durch Pattern Matching deutlich mächtiger.

Was ist ein Pattern in switch?

Es erlaubt, den Typ eines Objekts zu prüfen und es in eine lokale Variable zu entpacken – optional mit zusätzlichen Bedingungen. Kein instanceof mehr und kein Casten nötig.

Patterns mit Bedingungen:

Bedingungen lassen sich direkt in case-Zweige einbauen:

case Point p when p.x() > 0 -> System.out.println("Punkt liegt rechts");
          

Pattern Matching für switch ermöglicht:

• weniger Typumwandlungen,
• besser lesbaren Code,
• volle Kompatibilität mit sealed types und records,
• Vollständigkeitsprüfung durch den Compiler.

Versiegelte Klassen (Sealed Classes)

Die Vererbung in Java war immer offen. Java 17 führte den sealed-Modifier ein, und in Java 21 ist er nun vollständig stabilisiert.

Was sind versiegelte Klassen?

Damit kann man genau festlegen, welche Klassen eine Basisklasse erweitern dürfen.

public sealed class Shape permits Circle, Rectangle {}
public final class Circle extends Shape {}
public final class Rectangle extends Shape {}
          

Vorteile sind u.a.:

• Kontrolle über die Typen-Hierarchie,
• der Compiler kennt alle Unterklassen,
• kein default in switch nötig,
• perfekte Ergänzung zu record und Pattern Matching.

Fazit

Java 21 ist mehr als nur ein Paket neuer Features – es ist ein Schritt hin zu einem modernen, kompakten Programmierstil.

Der Code wird einfacher, ohne an Klarheit zu verlieren. Wer noch mit Java 11 oder 17 arbeitet, kann mit Java 21 sowohl bei Performance als auch bei Wartbarkeit profitieren.

Es lohnt sich, mit den neuen Features zu experimentieren und sie in Produktionscode zu bringen.